NameError in Admin::Usuarios#edit

48
49
50
51
52
53
              

        value = nil
        @output_buffer ||= ActionView::OutputBuffer.new
        buffer = @output_buffer.capture { value = yield(*args) }

        string = if @output_buffer.equal?(value)
          buffer

73
74
75
76
77
78
              

      new_buffer = +""
      old_buffer, @raw_buffer = @raw_buffer, new_buffer
      yield(*args)
      new_buffer.html_safe
    ensure
      @raw_buffer = old_buffer

48
49
50
51
52
53
              

        value = nil
        @output_buffer ||= ActionView::OutputBuffer.new
        buffer = @output_buffer.capture { value = yield(*args) }

        string = if @output_buffer.equal?(value)
          buffer

771
772
773
774
775
776
              

        if block_given?
          builder = instantiate_builder(scope, model, options)
          output  = capture(builder, &block)
          options[:multipart] ||= builder.multipart?

          html_options = html_options_for_form_with(url, model, **options)

13
14
15
16
17
18
              

  <%= render 'shared/flash' %>

  <%= form_with(model: usuario, url: usuario.new_record? ? admin_usuarios_path : admin_usuario_path(usuario),
                method: usuario.new_record? ? :post : :patch,
                class: 'bg-[#1a1a1a] rounded-2xl border border-white/5 p-8 space-y-6') do |f| %>

261
262
263
264
265
266
              

        end
      else
        public_send(method, locals, buffer, &block)
      end
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template

261
262
263
264
265
266
              

        end
      else
        public_send(method, locals, buffer, &block)
      end
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template

259
260
261
262
263
264
              

          nil
        else
          result = view._run(method_name, self, locals, OutputBuffer.new, add_to_stack: add_to_stack, has_strict_locals: strict_locals?, &block)
          result.is_a?(OutputBuffer) ? result.to_s : result
        end
      end

206
207
208
209
210
211
              

          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end
      end

554
555
556
557
558
559
              

      def instrument_render_template(&block)
        ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
      end

      def instrument_payload

247
248
249
250
251
252
              

    # consume this in production. This is only slow if it's being listened to.
    def render(view, locals, buffer = nil, implicit_locals: [], add_to_stack: true, &block)
      instrument_render_template do
        compile!(view)

        if strict_locals? && @strict_local_keys && !implicit_locals.empty?

250
251
252
253
254
255
              

          locals: locals
        ) do |payload|
          content = template.render(view, locals, add_to_stack: !block) do |*name|
            view._layout_for(*name, &block)
          end

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

244
245
246
247
248
249
              

      def render_partial_template(view, locals, template, layout, block)
        ActiveSupport::Notifications.instrument(
          "render_partial.action_view",
          identifier: template.identifier,
          layout: layout && layout.virtual_path,

235
236
237
238
239
240
              

      end

      render_partial_template(context, @locals, template, layout, block)
    end

    private

81
82
83
84
85
86
              

            # Partial
            renderer = PartialRenderer.new(@lookup_context, options)
            renderer.render(partial, context, block)
          end
        end
      else

53
54
55
56
57
58
              

    # Direct access to partial rendering.
    def render_partial(context, options, &block) # :nodoc:
      render_partial_to_object(context, options, &block).body
    end

    def cache_hits # :nodoc:

42
43
44
45
46
47
              

            options.render_in(self, &block)
          else
            view_renderer.render_partial(self, partial: options, locals: locals, &block)
          end
        end
      end

1
2
              

<%# app/views/usuarios/edit.html.erb %>
<%= render 'form', usuario: @usuario %>

261
262
263
264
265
266
              

        end
      else
        public_send(method, locals, buffer, &block)
      end
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template

261
262
263
264
265
266
              

        end
      else
        public_send(method, locals, buffer, &block)
      end
    ensure
      @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template

259
260
261
262
263
264
              

          nil
        else
          result = view._run(method_name, self, locals, OutputBuffer.new, add_to_stack: add_to_stack, has_strict_locals: strict_locals?, &block)
          result.is_a?(OutputBuffer) ? result.to_s : result
        end
      end

206
207
208
209
210
211
              

          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end
      end

554
555
556
557
558
559
              

      def instrument_render_template(&block)
        ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
      end

      def instrument_payload

247
248
249
250
251
252
              

    # consume this in production. This is only slow if it's being listened to.
    def render(view, locals, buffer = nil, implicit_locals: [], add_to_stack: true, &block)
      instrument_render_template do
        compile!(view)

        if strict_locals? && @strict_local_keys && !implicit_locals.empty?

64
65
66
67
68
69
              

            locals: locals
          ) do
            template.render(view, locals) { |*name| view._layout_for(*name) }
          end
        end
      end

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

58
59
60
61
62
63
              

      def render_template(view, template, layout_name, locals)
        render_with_layout(view, template, layout_name, locals) do |layout|
          ActiveSupport::Notifications.instrument(
            "render_template.action_view",
            identifier: template.identifier,
            layout: layout && layout.virtual_path,

74
75
76
77
78
79
              

        body = if layout
          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
            view.view_flow.set(:layout, yield(layout))
            layout.render(view, locals) { |*name| view._layout_for(*name) }
          end
        else

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

73
74
75
76
77
78
              

        body = if layout
          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
            view.view_flow.set(:layout, yield(layout))
            layout.render(view, locals) { |*name| view._layout_for(*name) }
          end

57
58
59
60
61
62
              

      # supplied as well.
      def render_template(view, template, layout_name, locals)
        render_with_layout(view, template, layout_name, locals) do |layout|
          ActiveSupport::Notifications.instrument(
            "render_template.action_view",
            identifier: template.identifier,

9
10
11
12
13
14
              

      prepend_formats(template.format)

      render_template(context, template, options[:layout], options[:locals] || {})
    end

    private

61
62
63
64
65
66
              

    def render_template_to_object(context, options) # :nodoc:
      TemplateRenderer.new(@lookup_context).render(context, options)
    end

    def render_partial_to_object(context, options, &block) # :nodoc:

29
30
31
32
33
34
              

        render_partial_to_object(context, options)
      else
        render_template_to_object(context, options)
      end
    end

133
134
135
136
137
138
              

        rendered_template = context.in_rendering_context(options) do |renderer|
          renderer.render_to_object(context, options)
        end

        rendered_format = rendered_template.format || lookup_context.formats.first

288
289
290
291
292
293
              

      end

      yield @view_renderer
    ensure
      @view_renderer = old_view_renderer
      @lookup_context = old_lookup_context

132
133
134
135
136
137
              

        lookup_context.variants = variant if variant

        rendered_template = context.in_rendering_context(options) do |renderer|
          renderer.render_to_object(context, options)
        end

254
255
256
257
258
259
              

          Body.new view_renderer.render_body(view_context, options)
        else
          super
        end
      end
  end

119
120
121
122
123
124
              

    def render_to_body(options = {})
      _process_options(options)
      _render_template(options)
    end

    private

156
157
158
159
160
161
              

    def render_to_body(options = {}) # :nodoc:
      super || _render_in_priorities(options) || " "
    end

    private

139
140
141
142
143
144
              

    # <tt>ActionView::Rendering.render_to_body</tt>, if present.
    def render_to_body(options)
      _render_to_body_with_renderer(options) || super
    end

    def _render_to_body_with_renderer(options)

25
26
27
28
29
30
              

    def render(*args, &block)
      options = _normalize_render(*args, &block)
      rendered_body = render_to_body(options)
      if options[:html]
        _set_html_content_type
      else

137
138
139
140
141
142
              

    def render(*args)
      raise ::AbstractController::DoubleRenderError if response_body
      super
    end

    # Similar to #render, but only returns the rendered template as a string,

27
28
29
30
31
32
              

      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output
    end

322
323
324
325
326
327
              

  def realtime # :yield:
    r0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
    yield
    Process.clock_gettime(Process::CLOCK_MONOTONIC) - r0
  end

12
13
14
15
16
              

  #   # => 0.074
  def ms(&block)
    1000 * realtime(&block)
  end
end

27
28
29
30
31
32
              

      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output
    end

96
97
98
99
100
101
              

      #   end
      def cleanup_view_runtime # :doc:
        yield
      end

      # Every time after an action is processed, this method is invoked

37
38
39
40
41
42
              

            db_rt_before_render = ActiveRecord::RuntimeRegistry.reset
            self.db_runtime = (db_runtime || 0) + db_rt_before_render
            runtime = super
            queries_rt = ActiveRecord::RuntimeRegistry.sql_runtime - ActiveRecord::RuntimeRegistry.async_sql_runtime
            db_rt_after_render = ActiveRecord::RuntimeRegistry.reset
            self.db_runtime += db_rt_after_render

26
27
28
29
30
31
              

    def render(*)
      render_output = nil
      self.view_runtime = cleanup_view_runtime do
        Benchmark.ms { render_output = super }
      end
      render_output

35
36
37
38
39
40
              

    def default_render
      if template_exists?(action_name.to_s, _prefixes, variants: request.variant)
        render
      elsif any_templates?(action_name.to_s, _prefixes)
        message = "#{self.class.name}\##{action_name} is missing a template " \
          "for this request format and variant.\n" \

5
6
7
8
9
10
              

    def send_action(method, *args)
      ret = super
      default_render unless performed?
      ret
    end

222
223
224
225
226
227
              

      # which is *not* necessarily the same as the action name.
      def process_action(...)
        send_action(...)
      end

      # Actually call the method associated with the action. Override

163
164
165
166
167
168
              

      def process_action(*) # :nodoc:
        self.formats = request.formats.filter_map(&:ref)
        super
      end

      def _process_variant(options)

257
258
259
260
261
262
              

      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end
  end

119
120
121
122
123
124
              

              current.invoke_before(env)
              if current.final?
                env.value = !env.halted && (!block_given? || yield)
              elsif current.skip?(env)
                (skipped ||= []) << current
                next_sequence = next_sequence.nested

22
23
24
25
26
27
              

    def with_request_id(request_id)
      old_request_id, self.current_request_id = self.current_request_id, request_id
      yield
    ensure
      self.current_request_id = old_request_id
    end

8
9
10
11
12
              

  private
    def turbo_tracking_request_id(&block)
      Turbo.with_request_id(request.headers["X-Turbo-Request-Id"], &block)
    end
end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

21
22
23
24
25
26
              

        previous_renderer = self.renderer
        self.renderer = renderer
        yield
      ensure
        self.renderer = previous_renderer
      end

67
68
69
70
71
72
              

        ActiveSupport.on_load(base) do
          around_action do |controller, action|
            ActionText::Content.with_renderer(controller, &action)
          end
        end
      end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

128
129
130
131
132
133
              

                begin
                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
                  target.send(method, *arguments, &block)
                ensure
                  next_sequence = current
                end

139
140
141
142
143
144
              

          end

          invoke_sequence.call
        end
      end
    end

256
257
258
259
260
261
              

      # <tt>process_action</tt> callbacks around the normal behavior.
      def process_action(...)
        run_callbacks(:process_action) do
          super
        end
      end

23
24
25
26
27
28
              

    private
      def process_action(*)
        super
      rescue Exception => exception
        request.env["action_dispatch.show_detailed_exceptions"] ||= show_detailed_exceptions?
        rescue_with_handler(exception) || raise

72
73
74
75
76
77
              

        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
          result = super
          payload[:response] = response
          payload[:status]   = response.status
          result

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

56
57
58
59
60
61
              

        handle.start
        begin
          yield payload if block_given?
        rescue Exception => e
          payload[:exception] = [e.class.name, e.message]
          payload[:exception_object] = e

204
205
206
207
208
209
              

      def instrument(name, payload = {})
        if notifier.listening?(name)
          instrumenter.instrument(name, payload) { yield payload if block_given? }
        else
          yield payload if block_given?
        end

71
72
73
74
75
76
              

        ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload)

        ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
          result = super
          payload[:response] = response
          payload[:status]   = response.status

259
260
261
262
263
264
              

      def process_action(*)
        _perform_parameter_wrapping if _wrapper_enabled?
        super
      end

      # Returns the wrapper key which will be used to store wrapped parameters.

30
31
32
33
34
35
              

          # and it won't be cleaned up by the method below.
          ActiveRecord::RuntimeRegistry.reset
          super
        end

        def cleanup_view_runtime

158
159
160
161
162
163
              

      @_response_body = nil

      process_action(action_name, *args)
    end
    ruby2_keywords(:process)

38
39
40
41
42
43
              

    def process(...) # :nodoc:
      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
      super
    ensure
      I18n.config = old_config
    end

225
226
227
228
229
230
              

      set_request!(request)
      set_response!(response)
      process(name)
      request.commit_flash
      to_a
    end

307
308
309
310
311
312
              

        middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
      else
        new.dispatch(name, req, res)
      end
    end
  end

47
48
49
50
51
52
              

          def dispatch(controller, action, req, res)
            controller.dispatch(action, req, res)
          end
      end

30
31
32
33
34
35
              

          controller = controller req
          res        = controller.make_response! req
          dispatch(controller, params[:action], req, res)
        rescue ActionController::RoutingError
          if @raise_on_name_error
            raise

49
50
51
52
53
54
              

          req.route_uri_pattern = route.path.spec.to_s

          _, headers, _ = response = route.app.serve(req)

          if "pass" == headers[Constants::X_CASCADE]
            req.script_name     = script_name

129
130
131
132
133
134
              

              path_parameters[name.to_sym] = Utils.unescape_uri(val) if val
            }
            yield [match_data, path_parameters, r]
          }
        end

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

122
123
124
125
126
127
              

          routes.sort_by!(&:precedence)

          routes.each { |r|
            match_data = r.path.match(path_info)
            path_parameters = {}
            match_data.names.each_with_index { |name, i|

30
31
32
33
34
35
              

      def serve(req)
        find_routes(req) do |match, parameters, route|
          set_params  = req.path_parameters
          path_info   = req.path_info
          script_name = req.script_name

880
881
882
883
884
885
              

        req = make_request(env)
        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
        @router.serve(req)
      end

      def recognize_path(path, environment = {})

34
35
36
37
38
39
              

      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

      result ||= {}

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

32
33
34
35
36
37
              

      env['warden'] = Proxy.new(env, self)
      result = catch(:warden) do
        env['warden'].on_request
        @app.call(env)
      end

18
19
20
21
22
23
              

      begin
        _, _, body = response = @app.call(env)
      rescue Exception
        env[RACK_TEMPFILES]&.each(&:close!)
        raise

27
28
29
30
31
32
              

    def call(env)
      status, headers, body = response = @app.call(env)

      if etag_status?(status) && body.respond_to?(:to_ary) && !skip_caching?(headers)
        body = body.to_ary

29
30
31
32
33
34
              

      case env[REQUEST_METHOD]
      when "GET", "HEAD"
        status, headers, body = response = @app.call(env)

        if status == 200 && fresh?(env, headers)
          response[0] = 304

13
14
15
16
17
18
              

    def call(env)
      _, _, body = response = @app.call(env)

      if env[REQUEST_METHOD] == HEAD
        body.close if body.respond_to?(:close)

34
35
36
37
38
39
              

      def call(env)
        _, headers, _ = response = @app.call(env)

        return response if policy_present?(headers)

34
35
36
37
38
39
              

      def call(env)
        status, headers, _ = response = @app.call(env)

        # Returning CSP headers with a 304 Not Modified is harmful, since nonces in the new
        # CSP headers might not match nonces in the cached HTML.

272
273
274
275
276
277
              

          req = make_request env
          prepare_session(req)
          status, headers, body = app.call(req.env)
          res = Rack::Response::Raw.new status, headers
          commit_session(req, res)
          [status, headers, body]

266
267
268
269
270
271
              

        def call(env)
          context(env)
        end

        def context(env, app = @app)

687
688
689
690
691
692
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      response = @app.call(env)

      if request.have_cookie_jar?
        cookie_jar = request.cookie_jar

653
654
655
656
657
658
              

        end

        @app.call(env)
      end

      private

27
28
29
30
31
32
              

      error = nil
      result = run_callbacks :call do
        @app.call(env)
      rescue => error
      end
      raise error if error

99
100
101
102
103
104
              

      if callbacks.empty?
        yield if block_given?
      else
        env = Filters::Environment.new(self, false, nil)

26
27
28
29
30
31
              

    def call(env)
      error = nil
      result = run_callbacks :call do
        @app.call(env)
      rescue => error
      end

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

14
15
16
17
18
19
              

    def call(env)
      request = ActionDispatch::Request.new(env)
      return @app.call(env) unless actionable_request?(request)

      ActiveSupport::ActionableError.dispatch(request.params[:error].to_s.safe_constantize, request.params[:action])

27
28
29
30
31
32
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if headers[Constants::X_CASCADE] == "pass"
        body.close if body.respond_to?(:close)

130
131
132
133
134
135
              

      def call_app(env)
        @app.call(env)
      rescue => e
        throw :app_exception, e
      end

17
18
19
20
21
22
              

      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

        if id = id_for_repl_session_update(request)
          return update_repl_session(id, request)

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

15
16
17
18
19
20
              

    def call(env)
      app_exception = catch :app_exception do
        request = create_regular_or_whiny_request(env)
        return call_app(env) unless request.permitted?

29
30
31
32
33
34
              

    def call(env)
      @app.call(env)
    rescue Exception => exception
      request = ActionDispatch::Request.new env
      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")

35
36
37
38
39
40
              

          logger.info { started_request_message(request) }
          status, headers, body = response = @app.call(env)
          body = ::Rack::BodyProxy.new(body, &handle.method(:finish))

          if response.frozen?

22
23
24
25
26
27
              

        if logger.respond_to?(:tagged)
          logger.tagged(*compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

137
138
139
140
141
142
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

37
38
39
40
41
42
              

      def tagged(*tags)
        pushed_count = tag_stack.push_tags(tags).size
        yield self
      ensure
        pop_tags(pushed_count)
      end

137
138
139
140
141
142
              

    def tagged(*tags)
      if block_given?
        formatter.tagged(*tags) { yield self }
      else
        logger = ActiveSupport::TaggedLogging.new(self)
        logger.formatter.extend LocalTagStorage

239
240
241
242
243
244
              

          super(name, *args, **kwargs, &block)
        elsif loggers.one?
          loggers.first.send(name, *args, **kwargs, &block)
        else
          loggers.map { |logger| logger.send(name, *args, **kwargs, &block) }
        end

22
23
24
25
26
27
              

        if logger.respond_to?(:tagged)
          logger.tagged(*compute_tags(request)) { call_app(request, env) }
        else
          call_app(request, env)
        end

9
10
11
12
13
14
              

      ::Rails.logger.silence { @app.call(env) }
    else
      @app.call(env)
    end
  end
end

90
91
92
93
94
95
              

      req = ActionDispatch::Request.new env
      req.remote_ip = GetIp.new(req, check_ip, proxies)
      @app.call(req.env)
    end

    # The GetIp class exists as a way to defer processing of the request data

26
27
28
29
30
31
              

      req = ActionDispatch::Request.new env
      req.request_id = make_request_id(req.headers[@header])
      @app.call(env).tap { |_status, headers, _body| headers[@header] = req.request_id }
    end

    private

26
27
28
29
30
31
              

      end

      @app.call(env)
    end

    def method_override(env)

22
23
24
25
26
27
              

    def call(env)
      start_time = Utils.clock_time
      _, headers, _ = response = @app.call(env)

      request_time = Utils.clock_time - start_time

57
58
59
60
61
62
              

      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

      headers = response[1]

22
23
24
25
26
27
              

        events = []
        ActiveSupport::IsolatedExecutionState[KEY] = events
        yield
        events
      ensure
        ActiveSupport::IsolatedExecutionState.delete(KEY)

56
57
58
59
60
61
              

    def call(env)
      response = nil
      events = @subscriber.collect_events do
        response = @app.call(env)
      end

12
13
14
15
16
17
              

      state = @executor.run!(reset: true)
      begin
        response = @app.call(env)

        if env["action_dispatch.report_exception"]
          error = env["action_dispatch.exception"]

35
36
37
38
39
40
              

      end
    else
      @app.call(env)
    end
  end

23
24
25
26
27
28
              

    def call(env)
      @file_handler.attempt(env) || @app.call(env)
    end
  end

129
130
131
132
133
134
              

    def call(env)
      _, headers, body = response = @app.call(env)

      if body.respond_to?(:to_path)
        case type = variation(env)

332
333
334
335
336
337
              

          status, headers, body = [200, { Rack::CONTENT_TYPE => 'text/html' }, [blank_page_html.dup]] # important to dup here!
        else
          status, headers, body = @app.call(env)
        end
      ensure
        trace.disable if trace

534
535
536
537
538
539
              

    def call(env)
      req = build_request env
      app.call req.env
    end

    # Defines additional Rack env configuration that is added on each call.

277
278
279
280
281
282
              

      def call(env)
        env[Const::PUMA_CONFIG] = @config
        @app.call(env)
      end
    end

97
98
99
100
101
102
              

        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else
          @log_writer.log "Unsupported HTTP method used: #{env[REQUEST_METHOD]}"

388
389
390
391
392
393
              

        t[:with_force_shutdown] = true
      end
      yield
    ensure
      t[:with_force_shutdown] = false
    end

96
97
98
99
100
101
              

      begin
        if @supported_http_methods == :any || @supported_http_methods.key?(env[REQUEST_METHOD])
          status, headers, app_body = @thread_pool.with_force_shutdown do
            @app.call(env)
          end
        else

470
471
472
473
474
475
              

        while true
          @requests_count += 1
          case handle_request(client, requests + 1)
          when false
            break
          when :async

252
253
254
255
256
257
              

      @status = :run

      @thread_pool = ThreadPool.new(thread_name, options) { |client| process_client client }

      if @queue_requests
        @reactor = Reactor.new(@io_selector_backend) { |c| reactor_wakeup c }

165
166
167
168
169
170
              

          begin
            @out_of_band_pending = true if block.call(work)
          rescue Exception => e
            STDERR.puts "Error reached top of thread-pool: #{e.message} (#{e.class})"
          end